import * as Icons from "@ant-design/icons";
import React from "react";

/**
 * @description 使用递归处理后台返回菜单 key 值为 antd 菜单需要的 key 值
 * @param {Array} menuList 所有菜单列表
 * @param {Array} newArr antd 菜单需要的 key 值（ key 值为 path）
 * @return array
 */
export const deepLoopFloat = (menuList, newArr = []) => {
    const getItem = (label, key, icon, children, type) => {
        return {key, icon, children, label, type}
    };
    // 动态渲染 Icon 图标
    const customIcons = Icons;
    const addIcon = (name) => {
        return React.createElement(customIcons[name]);
    };
    menuList.forEach((item) => {
        // 下面判断代码解释 *** !item?.children?.length   ==>   (!item.children || item.children.length === 0)
        if (!item?.children?.length) return newArr.push(getItem(item.title, item.path, addIcon(item.icon)));
        newArr.push(getItem(item.title, item.path, addIcon(item.icon), deepLoopFloat(item.children)));
    });
    return newArr;
};

/**
 * @description 递归查询对应的路由
 * @param {String} path 当前访问地址
 * @param {Array} routes 路由列表
 * @returns array
 */
export const searchRoute = (path, routes = []) => {
    let result = {}; // 用于存储递归搜索到的匹配结果
    for (let item of routes) { // 遍历传入的路由数组
        if (item.path === path) return item; // 如果当前路由的 path 与目标 path 匹配，直接返回该路由对象
        if (item.children) { // 如果当前路由有子路由
            const res = searchRoute(path, item.children); // 递归调用 searchRoute，在子路由中继续查找
            if (Object.keys(res).length) result = res; // 如果递归结果不为空对象（即找到了匹配的路由），将其赋值给 result
        }
    }
    return result; // 返回最终结果（可能是空对象，表示未找到匹配的路由）
};

/**
 * @description 获取需要展开的 subMenu
 * @param {String} path 当前访问地址
 * @returns array
 */
export const getOpenKeys = (path) => {
    let newStr = "";
    let newArr = [];
    let arr = path.split("/").map(i => "/" + i);
    for (let i = 1; i < arr.length - 1; i++) {
        newStr += arr[i];
        newArr.push(newStr);
    }
    return newArr;
};

/*************/

/**
 * @description 递归当前路由的 所有 关联的路由，生成面包屑导航栏
 * @param {String} path 当前访问地址
 * @param {Array} menuList 菜单列表
 * @returns array
 */
export const getBreadcrumbList = (path, menuList) => {
    let tempPath = [];
    try {
        const getNodePath = (node) => {
            tempPath.push(node);
            // 找到符合条件的节点，通过throw终止掉递归
            if (node.path === path) {
                throw new Error("GOT IT!");
            }
            if (node.children && node.children.length > 0) {
                for (let i = 0; i < node.children.length; i++) {
                    getNodePath(node.children[i]);
                }
                // 当前节点的子节点遍历完依旧没找到，则删除路径中的该节点
                tempPath.pop();
            } else {
                // 找到叶子节点时，删除路径当中的该叶子节点
                tempPath.pop();
            }
        };
        for (let i = 0; i < menuList.length; i++) {
            getNodePath(menuList[i]);
        }
    } catch (e) {
        return tempPath.map(item => item.title);
    }
};

/**
 * @description 使用递归处理路由菜单，生成一维数组，做菜单权限判断
 * @param {Array} menuList 所有菜单列表
 * @param {Array} newArr 菜单的一维数组
 * @return array
 */
export function handleRouter(routerList, newArr = []) {
    routerList.forEach((item) => {
        typeof item === "object" && item.path && newArr.push(item.path);
        item.children && item.children.length && handleRouter(item.children, newArr);
    });
    return newArr;
}

/**
 * @description 双重递归 找出所有 面包屑 生成对象存到 redux 中，就不用每次都去递归查找了
 * @param {String} menuList 当前菜单列表
 * @returns object
 */
export const findAllBreadcrumb = menuList => {
    let handleBreadcrumbList = {};
    const loop = (menuItem) => {
        // 下面判断代码解释 *** !item?.children?.length   ==>   (item.children && item.children.length > 0)
        if (menuItem?.children?.length) menuItem.children.forEach(item => loop(item));
        else handleBreadcrumbList[menuItem.path] = getBreadcrumbList(menuItem.path, menuList);
    };
    menuList.forEach(item => loop(item));
    return handleBreadcrumbList;
};